/**
 * @file regroupement.c
 * @brief Fichier d'implémentation du module regroupement.
 *
 * @author Rachid Delory , Florian Bernard, Mamadou Keita
 */

#include "regroupement.h"


/* *********************************************************************

                 Fonctions relatives aux regroupement                      

********************************************************************* */

void init_Reg(Regroupement * regrp) 
{
  if (regrp)
    {
      regrp->id = 0;
      regrp->illustration = NULL ; 
      regrp->titre = NULL ;
      regrp->type = 0;
      regrp->commentaire = NULL ;
      regrp->creation = NULL ; 
      regrp->eGenre = creer_Ens();
      regrp->maj = 0;
      regrp->sup = 0;
    }
}

void liberer_Reg(Regroupement * regrp)
{
  if(regrp)
    {
      regrp->id = 0;
      if(regrp->illustration != NULL)
	{
	  free(regrp->illustration);
	  regrp->illustration = NULL;
	}
      if(regrp->titre != NULL)
	{
	  free(regrp->titre);
	  regrp->titre = NULL ;
	}
      regrp->type = 0;
      if(regrp->commentaire != NULL)
	{
	  free(regrp->commentaire);
	  regrp->commentaire = NULL ;
	}
      if(regrp->creation != NULL)
	{
	  detruire_Dat(&(regrp->creation));
	  regrp->creation = NULL ; 
	}
      detruire_Ens(&(regrp->eGenre), detruire_Gen);
    }
}

Regroupement * creer_Reg()
{
  Regroupement *regrp = (Regroupement*) malloc (1 * sizeof (Regroupement));
  if(regrp)
    init_Reg(regrp);
  else
    {
      fprintf(stderr, "Mémoire insuffisante");
      exit(EXIT_FAILURE);
    }
  return regrp;
}

void detruire_Reg(Regroupement ** regrp)
{
  if(regrp)
    {
      liberer_Reg((*regrp));
    }
  free((*regrp));
  (*regrp) = NULL;
}

void copier_Reg(Regroupement ** regrpDest, const Regroupement *regrpSrc)
{
  if((*regrpDest) == NULL)
    (*regrpDest) = creer_Reg();
  if(regrpSrc) 
    {
      Ensemble *ens = getEnsembleGenre_Reg((*regrpDest));
      setId_Reg((*regrpDest), getId_Reg(regrpSrc));
      setIllustration_Reg((*regrpDest), getIllustration_Reg(regrpSrc));
      setTitre_Reg((*regrpDest), getTitre_Reg(regrpSrc));
      setType_Reg((*regrpDest), getType_Reg(regrpSrc));
      setCommentaire_Reg((*regrpDest), getCommentaire_Reg(regrpSrc));
      setCreation_Reg((*regrpDest), getCreation_Reg(regrpSrc));
      copier_Ens(&ens, getEnsembleGenre_Reg(regrpSrc), creer_Gen, detruire_Gen, copier_Gen);
    }
  else
    detruire_Reg(regrpDest);
}
/* ********************************************************************* 

           Accesseurs et Mutateurs de la structure sRegroupement             

********************************************************************* */

unsigned int getId_Reg(const Regroupement *regrp)
{
  if(regrp)
    return (regrp->id);

  return 0;
}

void setId_Reg(Regroupement *regrp, const unsigned int id) 
{
  if(regrp)
    regrp->id = id;
}

char * getIllustration_Reg(const Regroupement *regrp)
{
    if(regrp)
      return (regrp->illustration);

    return NULL;
}

void setIllustration_Reg(Regroupement *regrp, const char * illustration)
{
  if(regrp)
       {
	 if(regrp->illustration != NULL)
	   {
	     free(regrp->illustration);
	     regrp->illustration = NULL;
	   }
	 if(illustration == NULL)
	   return;
	 regrp->illustration = (char *) malloc ((strlen(illustration) + 1) * sizeof(char));
	 if(regrp->illustration == NULL)
	   {
	     fprintf(stderr, "Mémoire insuffisante");
	     exit(EXIT_FAILURE);
	   }
	 strcpy(regrp->illustration, illustration);
    }
}

char * getTitre_Reg(const Regroupement *regrp)
{
    if(regrp)
      return (regrp->titre);
    return NULL;
}

void setTitre_Reg(Regroupement *regrp, const char * titre)
{
   if(regrp)
     {
       if(regrp->titre != NULL)
	 {
	   free(regrp->titre);
	   regrp->titre = NULL;
	 }
       if(titre == NULL)
	 return;
       regrp->titre = (char *) malloc ((strlen(titre)+1) * sizeof(char));
       if(regrp->titre == NULL)
	 {
	   fprintf(stderr, "Mémoire insuffisante");
	   exit(EXIT_FAILURE);
	 }
       strcpy(regrp->titre,titre);
     }
}

unsigned int getType_Reg(const Regroupement *regrp)
{
  if(regrp)
    return (regrp->type);
  return 0/* Il faut que l'on fasse les ENUMs dont on a besoin et prevoir dans chacun ERREUR */;
}

void setType_Reg(Regroupement *regrp, const unsigned int type) 
{
 if(regrp)
    regrp->type = type;
}

char * getCommentaire_Reg(const Regroupement *regrp)
{
  if(regrp)
    return (regrp->commentaire);
  return NULL;
}

void setCommentaire_Reg(Regroupement *regrp, const char * commentaire) 
{
   if(regrp)
     {
       if(regrp->commentaire != NULL)
	 {
	   free(regrp->commentaire);
	   regrp->commentaire = NULL;
	 }
       if(commentaire == NULL)
	 return;
       regrp->commentaire = (char *) malloc ((strlen(commentaire) + 1)*sizeof(char));
       if(regrp->commentaire == NULL)
	 {
	   fprintf(stderr, "Mémoire insuffisante");
	   exit(EXIT_FAILURE);
	 }
       strcpy(regrp->commentaire, commentaire);
     }
}


Date * getCreation_Reg(const Regroupement *regrp)
{
  if(regrp)
    return (regrp->creation);
  return NULL;
}

void setCreation_Reg(Regroupement *regrp, const Date * creation) 
{
 if(regrp)
   {
     if(regrp->creation == NULL)
       {
	 regrp->creation = creer_Dat();
       }
     if(creation == NULL)
	 detruire_Dat(&(regrp->creation));
     else
       copier_Dat(&(regrp->creation), creation);
   }
}

Ensemble * getEnsembleGenre_Reg(const Regroupement *regrp)
{
  if(regrp)
    return (regrp->eGenre);
  return NULL;
}

/* ********************************************************************* 

                       Test de Non Régression

********************************************************************* */

void regressionDynamique_Reg()
{
  Regroupement **regroupement;
  int i, nbRegroupement = 1000;
  regroupement = (Regroupement **) malloc (nbRegroupement * sizeof(Regroupement *));
  for(i = 0; i < nbRegroupement; i++)
    {
      regroupement[i] = creer_Reg();
      setId_Reg(regroupement[i], i);
      setTitre_Reg(regroupement[i], "Titre");
    }
  for(i = 0 ; i < nbRegroupement ; i++)
    detruire_Reg(&regroupement[i]);
  free(regroupement);
}

void setMaj_Reg(Regroupement *ptr, const char b)
{
  if(ptr)
    {
      ptr->maj = b;
      if(b == 1)
	ptr->sup = !b;
    }
}

char getMaj_Reg(const Regroupement *ptr)
{
  if(ptr)
    return ptr->maj;
  return 0;
}

void setSup_Reg(Regroupement *ptr, const char b)
{
  if(ptr)
    {
      ptr->sup = b;
      if(b == 1)
	ptr->maj = !b;
    }
}

char getSup_Reg(const Regroupement *ptr)
{
  if(ptr)
    return ptr->sup;
  return 0;
}


void regression_Reg()
{
}
